#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
using namespace std;

//class Time
//{
//public:
//	//Time(int hour = 0)
//	Time(int hour)
//	{
//		_hour = hour;
//	}
//private:
//	int _hour;
//};
//
//class Date
//{
//public:
//	// 要初始化_t 对象，必须通过初始化列表
//	Date(int year, int hour)
//		:_t(hour)
//	{
//		// 函数体内初始化
//		_year = year;
//		//Time t(hour);
//		//_t = t;
//	}
//private:
//	int _year;
//	Time _t;
//};
//
//int main()
//{
//	Date d(2022, 1);
//
//	return 0;
//}

//class Time
//{
//public:
//	Time(int hour = 0)
//	{
//		_hour = hour;
//	}
//private:
//	int _hour;
//};
//
//class Date
//{
//public:
//	// 要初始化_t 对象，可以再函数体内赋值，但是还是会走初始化列表调用Time的默认构造
//	//Date(int year, int hour)
//	//{
//	//	// 函数体内初始化
//	//	_year = year;
//	//	Time t(hour);
//	//	_t = t;
//	//}
//
//
//	Date(int year, int hour, int& x)
//		:_t(hour)
//		, _N(10)
//		, _ref(x)
//	{
//		// 函数体内初始化
//		_year = year;
//		_ref++;
//	}
//private:
//	int _year;
//	Time _t;
//	const int _N;
//	int& _ref;
//};
//
//// 结论：自定义类型成员，推荐用初始化列表初始化
//// 初始化列表可以认为是成员变量定义的地方
//
//int main()
//{
//	int y = 0;
//	Date d(2022, 1, y);
//	//const int N; // const必须在定义的地方初始化，只有一次机会
//
//	return 0;
//}

/////////////////////////////////////////////////////////////////////////////////////////////
//class Time
//{
//public:
//	Time(int hour = 0)
//	{
//		_hour = hour;
//	}
//private:
//	int _hour;
//};
//
//
//// 结论：自定义类型成员，推荐用初始化列表初始化
//// 初始化列表可以认为是成员变量定义的地方
//
//class Date
//{
//public:
//	//Date(int year, int hour, int& x)
//	//	: _N(10)
//	//	, _ref(x)
//	//{
//	//	// 函数体内初始化
//	//	_year = year;
//	//	_ref++;
//	//}
//	Date(int year, int hour, int& x)
//		:_year(year)
//		, _t(hour)
//		,_N(10)
//		, _ref(x)
//	{
//		_ref++;
//	}
//private:
//	// 声明
//	int _year = 0;  // C++11  缺省值-- 初始化时没有显示给值就会用这个缺省值
//	Time _t;
//	const int _N;
//	int& _ref;
//};
//
//int main()
//{
//	int y = 0;
//	Date d(2022, 1, y);
//
//	return 0;
//}

///////////////////////////////////////////////////////////////////////////////////////////////
//class A
//{
//public:
//	/*A(int N)
//		:_a((int*)malloc(sizeof(int)*N))
//		, _N(N)
//	{
//		if (_a == NULL)
//		{
//			perror("malloc fail");
//		}
//		memset(_a, 0, sizeof(int)*N);
//	}*/
//
//	// 有些初始化工作还是必须在函数体内完成
//	A(int N)
//		:_N(N)
//	{
//		_a = (int*)malloc(sizeof(int)*N);
//		if (_a == NULL)
//		{
//			perror("malloc fail");
//		}
//		memset(_a, 0, sizeof(int)*N);
//	}
//private:
//	// 声明
//	int* _a;
//	int _N;
//};
//
//int main()
//{
//	A aa(10);
//
//	return 0;
//}

// 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
//class A
//{
//public:
//	// 初始化按声明顺序初始化
//	A(int a)
//	// 成员变量定义
//		:_a1(a)
//		, _a2(_a1)
//	{}
//
//	void Print() {
//		cout << _a1 << " " << _a2 << endl;
//	}
//private:
//	// 成员变量声明
//	int _a2;
//	int _a1;
//};
//
////A.输出1  1
////B.程序崩溃
////C.编译不通过
////D.输出1  随机值
//
//int main() {
//	// D
//	// 对象定义
//	A aa1(1);
//	aa1.Print();
//
//	A aa2(2);
//
//}

//////////////////////////////////////////////////////////////////////////
// explicit关键字 + 匿名对象
//class Date
//{
//public:
//	//explicit Date(int year)
//	Date(int year)
//		:_year(year)
//	{
//		cout << "	Date(int year)" << endl;
//	}
//
//	Date(const Date& d)
//	{
//		cout << "Date(const Date& d)" << endl;
//	}
//
//	~Date()
//	{
//		cout << "~Date()" << endl;
//	}
//private:
//	int _year;
//};
//
////string(const char* str)
////{}
//
//void func(const string& s)
//{}
//
//class Solution {
//public:
//	int Sum_Solution(int n) {
//		// ...
//		return 0;
//	}
//};
//
//int main()
//{
//	Date d1(2022);  // 直接调用构造
//	Date d2 = 2022; // 隐式类型转换：构造 + 拷贝构造 + 编译器优化 -》直接调用构造 
//	const Date& d3 = 2022;
//
//	int i = 10;
//	const double& d = i;
//
//	// 匿名对象 -- 声明周期只有这一行
//	Date(2000);
//
//	Date d4(2000);
//
//	// 匿名对象 一些使用场景
//	Solution slt;
//	slt.Sum_Solution(10);
//	Solution().Sum_Solution(10);
//
//	string s1("hello");
//	string s2 = "hello";
//
//	string str("insert");
//	func(str);
//	func("insert");
//
//
//	return 0;
//}

////////////////////////////////////////////////////////////////////////////////

//class A
//{
//public:
//	A() 
//	{ ++_scount; }
//
//	A(const A& t) { ++_scount; }
//
//	// 静态成员函数 --  没有this指针
//	static int GetCount()
//	{
//		//_a = 1;
//
//		return _scount;
//	}
//
//private:
//	int _a;
//	// 静态成员变量，属于整个类，生命周期整个程序运行期间，存在静态取
//	static int _scount;  // 声明
//};
//
//// 类外面定义初始化
//int A::_scount = 0;
//
////int main()
////{
////	A a1;
////	A a2;
////	A a3(a2);
////
////	//cout << a1._scount << endl;
////	//cout << a2._scount << endl;
////	//cout << A::_scount << endl;
////
////	cout <<A::GetCount() << endl;
////
////	return 0;
////}
//
// 设计一个只能在栈上定义对象的类
// class StackOnly
//{
//public:
//	static StackOnly CreateObj()
//	{
//		StackOnly so;
//		return so;
//	}
//
//private:
//	StackOnly(int x = 0, int y = 0)
//		:_x(x)
//		, _y(0)
//	{
//
//	}
//
//	int _x = 0;
//	int _y = 0;
//};
//
//int main()
//{
//	//StackOnly so1; // 栈
//	//static StackOnly so2; // 静态区
//	StackOnly so3 = StackOnly::CreateObj();
//
//	return 0;
//}
//class StackOnly
//{
//public:
//	static StackOnly CreateObj()
//	{
//		StackOnly so;
//		return so;
//	}
//
//private:
//	StackOnly(int x = 0, int y = 0)
//		:_x(x)
//		, _y(0)
//	{}
//private:
//	int _x = 0;
//	int _y = 0;
//};
//
//int main()
//{
//	StackOnly so1; // 栈
//	static StackOnly so2; // 静态区
//	StackOnly so3 = StackOnly::CreateObj();
//
//	return 0;
//}

///////////////////////////////////////////////////////////////////////////////////////////
// 内部类
//class A
//{
//private:
//	int _h;
//	static int k;
//public:
//	// B定义在A的里面
//	// 1、受A的类域限制，访问限定符
//	// 2、B天生是A的友元
//	class B
//	{
//	public:
//		void foo(const A& a)
//		{
//			cout << k << endl;//OK
//			cout << a._h << endl;//OK -- 友元
//		}
//	private:
//		int _b;
//	};
//};
//int A::k = 1;
//
//int main()
//{
//	cout << sizeof(A) << endl; // 4
//	A a;
//	A::B b;
//
//	return 0;
//}
//

//class W
//{
//public:
//	W(int x = 0)
//	{
//		cout << "W()" << endl;
//	}
//
//	W(const W& w)
//	{
//		cout << "W(const W& w)" << endl;
//	}
//
//	W& operator=(const W& w)
//	{
//		cout << "W& operator=(const W& w)" << endl;
//		return *this;
//	}
//
//	~W()
//	{
//		cout << "~W()" << endl;
//	}
//};
//
//void f1(W w)
//{
//
//}
//
//void f2(const W& w)
//{
//
//}

//int main()
//{
//	W w1;
//	f1(w1);
//	f2(w1);
//	cout << endl << endl;
//
//	f1(W()); // 本来构造+拷贝构造--编译器的优化--直接构造
//	// 结论：连续一个表达式步骤中，连续构造一般都会优化 -- 合二为一
//
//	W w2 = 1;
//
//	return 0;
//}

//W f3()
//{
//	W ret;
//	return ret;
//}

// 《深度探索C++对象模型》
//int main()
//{
//	f3(); // 1次构造  1次拷贝
//	cout << endl << endl;
//
//	W w1 = f3(); // 本来：1次构造  2次拷贝 -- 优化：1次构造  1次拷贝
//
//	cout << endl << endl;
//
//	W w2;
//	w2 = f3(); // 本来：1次构造  1次拷贝 1次赋值
//
//	return 0;
//}

//W f(W u)
//{
//	//cout << "--------" << endl;
//	W v(u);
//	W w = v;
//	//cout << "--------" << endl;
//	return w;
//}
//
//int main()
//{
//	W x;
//	W y = f(f(x)); // 1次构造  7次拷贝  or  1次构造  5次拷贝
//
//	return 0;
//}

//int main()
//{
//	W x;
//	W y = f(x); // 1次构造  4次拷贝
//
//	return 0;
//}













//class A
//{
//public:
//	A(int a)
//		:_a1(a)
//		, _a2(_a1)
//	{
//
//	}
//
//	void Print()
//	{
//		cout << _a1 << " " << _a2 << endl;
//	}
//private:
//	int _a2;
//	int _a1;
//};

//class Date 
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		this->_year = year;
//		this->_month = month;
//		this->_day = day;
//	}
//	int Get()
//	{
//		return _N;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//
//	const int _N = 1;
//};
//class A
//{
//public:
//	A(int a  = 1)
//	{
//		_a = a;
//		cout << _a << endl;
//	}
//private:
//	int _a;
//};
//
//class B
//{
//public:
//	B()
//	{
//		int _b = 2;
//
//		int _i = 10;
//		int& _ref = _i; // 引用
//		const int _N = 20;
//		cout << _b << " " <<  _i << " " << _ref << " " << _N << endl;
//	}
//
//private:
//};
//
//int main() 
//{
//	B b;
//	return 0;
//}

//class A
//{
//public:
//	A(int a)
//		:_a(a)
//	{}
//private:
//	int _a;
//};
//class B
//{
//public:
//	B(int a, int ref)
//		: _ref(ref)
//		, _n(10)
//	{}
//private:
//	A _aobj;// 没有默认构造函数
//	int& _ref; // 引用
//	const int _n; // const 
//};
//int main() 
//{
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//		:_year(year)
//		,_month(month)
//		,_day(day)
//	{
//	}
//
//	void Print()
//	{
//		cout << _year << "年" << _month << "月" << _day << "日" << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d(2023, 5, 7);
//	d.Print();
//	return 0;
//}

//class A
//{
//public:
//	A(int a)
//		:_a1(a)
//		, _a2(_a1)
//	{
//
//	}
//
//	void Print() 
//	{
//		cout << _a1 << " " << _a2 << endl;
//	}
//private:
//	int _a2;
//	int _a1;
//};
//int main() 
//{
//	A aa(1);
//	aa.Print();
//}



//explicit

//int main()
//{
//	double d = 5.7;
//	int i = d;
//
//	cout << d << endl << i << endl;
//
//	return 0;
//}

//class Date 
//{
//public:
//	Date(int year,int day)
//		: _year(year)
//		,_day(day)
//	{
//		
//	}
//
//	void Print()
//	{
//		cout << _year  << " " << _day << endl;
//	}
//
//private:
//	int _year;
//	int _day;
//};
//
//int main()
//{
//	Date d1 = (2022,1);
//	d1.Print();
//
//	return 0;
//}


/////////////////////////////////////////static
//int n = 0;  // 全局变量
//
//class A 
//{
//public:
//	A(int a = 0)
//		: _a(a) 
//	{
//		n++;
//	}
//	A(const A& aa)
//		: _a(aa._a)
//	{
//		n++;
//	}
//
//private:
//	int _a;
//};
//
//void f(A a) 
//{
//	;
//}

//class A 
//{
//public:
//	A(int a = 0)
//		: _a(a) 
//	{
//		_sn++;
//	}
//	A(const A& aa)
//		: _a(aa._a) 
//	{
//		_sn++;
//	}
//	static int Get_sn() 
//	{
//		return _sn;
//	}
//private:
//	int _a;
//	static int _sn;
//};
//
//int A::_sn = 0;//静态的成员变量一定要在类外进行初始化。
//
//void f(A a) 
//{
//	;
//}
//
//int main()
//{
//	A a1;
//	A a2 = 1;
//	f(a1);
//
//	cout << A::Get_sn() << endl;  // 使用类域对它进行访问
//
//	// 这里不是说是在 a1 里面找，这里只是帮助他突破类域
//	cout << a1.Get_sn() << endl;
//	cout << a2.Get_sn() << endl;
//
//	return 0;
//}





/////////////////////////友元函数    流插入流提取
//#include <iostream>
//using namespace std;
//
//class Date 
//{
//	friend ostream& operator<<(ostream& out, const Date& d);// 友元的声明
//	friend istream& operator>>(istream& in, Date& d);
//
//public:
//	Date(int year = 1, int month = 1, int day = 1) 
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print() const 
//	{
//		cout << _year << "年" << _month << "月" << _day << "日" << endl;
//	}
//
//	void operator<<(ostream& out)
//	{
//		out << _year << "年" << _month << "月" << _day << "日" << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//ostream& operator<<(ostream& out, const Date& d)
//{
//	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
//	return out;
//}
//istream& operator>>(istream& in, Date& d) 
//{
//	in >> d._year >> d._month >> d._day;
//	return in;
//}
//
//int main()
//{
//	Date d1(2023, 5, 7);
//	Date d2(2023, 5, 8);
//	//d1.Print();
//	cout << d1 << d2;
//	//d1 << cout;
//
//	Date d3;
//	Date d4;
//	cin >> d3 >> d4;
//	cout << d3 << d4 << endl;
//
//	return 0;
//}


/////////////////////////友元类
//#include<iostream>
//using namespace std;
//
//class Date;   // 前置声明
//
//class Time
//{
//	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
//public:
//	Time(int hour = 0, int minute = 0, int second = 0)
//		: _hour(hour)
//		, _minute(minute)
//		, _second(second)
//	{}
//
//private:
//	int _hour;
//	int _minute;
//	int _second;
//};
//
//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//		: _year(year)
//		, _month(month)
//		, _day(day)
//	{}
//
//	void GetTime()
//	{
//		// 直接访问Time类私有的成员变量
//		cout << _t._hour << ":" << _t._minute << ":" << _t._second << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//	Time _t;
//};
//
//int main()
//{
//	Date d;
//	d.GetTime();
//
//	return 0;
//}
//
///////////////////////////内部类
//#include<iostream>
//using namespace std;
//
//class A
//{
//
//public:
//	class B // B天生就是A的友元
//	{
//	public:
//		void fuc(const A& a)
//		{
//			cout << g << endl;
//			cout << a.r << endl;
//		}
//	};
//
//private:
//	static int g;
//	int r = 19;
//};
//
//int A::g = 1;
//
//int main()
//{
//	A a;
//	A::B b;
//	b.fuc(a);
//
//	return 0;
//}
//#include<iostream>
//using namespace std;
//
//class A 
//{
//private:
//	static int _s_a1;
//	int _a2;
//
//public:
//	class B 
//	{
//	private:
//		int _b1;
//	};
//};
//
//int A::_s_a1 = 1;
//
//int main()
//{
//	cout << "A的大小为: " << sizeof(A) << endl;
//
//	return 0;
//}
//
////////////////////////////////////////匿名对象
//#include<iostream>
//using namespace std;
//
//class A
//{
//public:
//	A(int a = 0)
//		:_a(a)
//	{
//		cout << "A(int a)" << endl;
//	}
//
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//
//private:
//	int _a;
//};
//
//int main()
//{
//	A aa1;
//	//A aa1(); 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
//	// 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
//	// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
//	A();
//	A aa2;
//
//	return 0;
//}
//
////////////////////////////////////////拷贝对象时的一些编译器优化
//#include<iostream>
//using namespace std;
//
//class A
//{
//public:
//	A(int a = 0)
//		:_a(a)
//	{
//		cout << "A(int a)" << endl;
//	}
//	A(const A& aa)
//		:_a(aa._a)
//	{
//		cout << "A(const A& aa)" << endl;
//	}
//	A& operator=(const A& aa)
//	{
//		cout << "A& operator=(const A& aa)" << endl;
//		if (this != &aa)
//		{
//			_a = aa._a;
//		}
//		return *this;
//	}
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//private:
//	int _a;
//};
//
//void f1(A aa)
//{}
//
//A f2()
//{
//	A aa;
//	return aa;
//}
//
//int main()
//{
//	// 传值传参
//	A aa1;
//	f1(aa1);
//	cout << endl;
//
//	// 传值返回
//	f2();
//	cout << endl;
//
//	// 隐式类型，连续构造+拷贝构造->优化为直接构造
//	f1(1);
//	cout << endl;
//
//	// 一个表达式中，连续构造+拷贝构造->优化为一个构造
//	f1(A(2));
//	cout << endl;
//
//	// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
//	A aa2 = f2();
//	cout << endl;
//
//	// 一个表达式中，连续拷贝构造+赋值重载->无法优化
//	aa1 = f2();
//	cout << endl;
//	return 0;
//}

////思路：
//// 1. 分别求出每一个日期与0000年0月1日距离的天数
//// 2. 两个距离天数相减即可得到两个日期相差的天数
//#include <iostream>
//using namespace std;
////给出年月日，计算距离0000年0月1日的天数和
//int CountDay(int y, int m, int d)
//{
//    // 计算0-y年的天数
//    int yearDay = y * 365 + y / 4 - y / 100 + y / 400;
//    //平年从1月到n月的天数
//    int mon[12] = { 0,31,59,90,120,151,181,212,243,273,304,334 };
//    // 计算到0-m月的天数
//    int monthDay = mon[m - 1];
//    if (m > 2 && ((y % 4 == 0 && y % 100 != 0) || y % 400 == 0))
//    {
//        monthDay += 1;
//    }
//    return yearDay + monthDay + d;
//}
//
//int main()
//{
//    int year1, month1, day1;
//    scanf("%4d%2d%2d", &year1, &month1, &day1);
//    int n1 = CountDay(year1, month1, day1);
//
//    int year2, month2, day2;
//    scanf("%4d%2d%2d", &year2, &month2, &day2);
//    int n2 = CountDay(year2, month2, day2);
//
//    cout << abs(n1 - n2) + 1 << endl;
//}


//#include<iostream>
//using namespace std;
//class Date {
//    friend istream& operator>>(istream& in, Date& d);
//
//public:
//    Date(int year, int month, int day)
//        : _year(year)
//        , _month(month)
//        , _day(day)
//    {}
//
//    int GetMonthDay(int year, int month) { // 获取某年某月的天数
//        static int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
//        int day = days[month];
//        if (month == 2
//            && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))) {
//            day += 1;
//        }
//        return day;
//    }
//    bool operator==(const Date& d) const;
//    bool operator>(const Date& d) const;
//    bool operator!=(const Date& d) const;
//    bool operator>=(const Date& d) const;
//    bool operator<(const Date& d) const;
//    bool operator<=(const Date& d) const;
//
//    Date& operator+=(int day);
//    Date& operator++(); // 前置
//    int operator-(const Date& d) const; //日期减日期
//private:
//    int _year;
//    int _month;
//    int _day;
//};
//
//istream& operator>>(istream& in, Date& d) {
//    in >> d._year >> d._month >> d._day;
//    return in;
//}
//
//Date& Date::operator+=(int day) { //这里没考虑day是负数的情况，最后放的代码加上了
//    _day += day;
//    while (_day > GetMonthDay(_year, _month)) {
//        _day -= GetMonthDay(_year, _month);
//        _month++;
//        if (_month == 13) {
//            _year++;
//            _month = 1;
//        }
//    }
//    return *this;
//}
//
//Date& Date::operator++() { // 前置
//    return  *this += 1;
//}
//
//// 任何一个类，只需要写一个> == 或者 < ==重载 剩下比较运算符重载复用即可
//bool  Date::operator== (const Date& d) const {
//    return _year == d._year
//        && _month == d._month
//        && _day == d._day;
//}
//
//bool Date::operator>(const Date& d) const {
//    if ((_year > d._year)
//        || (_year == d._year && _month > d._month)
//        || (_year == d._year && _month == d._month && _day > d._day)) {
//        return true;
//    }
//    else {
//        return false;
//    }
//}
//
//bool Date::operator!=(const Date& d) const {
//    return !(*this == d);
//}
//
//bool Date::operator>=(const Date& d) const {
//    return (*this > d) || (*this == d);
//}
//
//bool Date::operator<(const Date& d) const {
//    return !(*this >= d);
//}
//
//bool Date::operator<=(const Date& d) const {
//    return !(*this > d);
//}
//int Date::operator-(const Date& d) const {
//    int ret = 0;
//    int flag = -1;
//    Date min = *this;//默认第一个小，返回的时候乘上 -1
//    Date max = d;
//
//    if (*this > d) { //默认错误，把小和大重置，返回时乘上 1
//        flag = 1;
//        min = d;
//        max = *this;
//    }
//
//    while (min != max) {
//        ++min;
//        ++ret;
//    }
//
//    return ret * flag;
//}
//
//int main() {
//    int tmp1 = 0, tmp2 = 0;
//    cin >> tmp1 >> tmp2;
//    Date date1(tmp1 / 10000, tmp1 % 10000 / 100, tmp1 % 100);
//    Date date2(tmp2 / 10000, tmp2 % 10000 / 100, tmp2 % 100);
//    cout << (date2 - date1) + 1 << endl;
//    return 0;
//}

int main()
{
	const char* p1 = "rtx";
	char p2[] = "rwwwtx";
	cout << sizeof(p1) << endl;
	cout << sizeof(p2) << endl;
	return 0;
}